home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 January: Mac OS SDK / Dev.CD Jan 99 SDK1.toast / Development Kits / Interfaces&Libraries / Universal / Interfaces / PInterfaces / Video.p < prev    next >
Encoding:
Text File  |  1998-08-17  |  35.2 KB  |  776 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Video.p
  3.  
  4.      Contains:    Video Driver Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1986-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Video;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __VIDEO__}
  27. {$SETC __VIDEO__ := 1}
  28.  
  29. {$I+}
  30. {$SETC VideoIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __QUICKDRAW__}
  34. {$I Quickdraw.p}
  35. {$ENDC}
  36.  
  37.  
  38. {$PUSH}
  39. {$ALIGN MAC68K}
  40. {$LibExport+}
  41.  
  42.  
  43. CONST
  44.     mBaseOffset                    = 1;                            { Id of mBaseOffset. }
  45.     mRowBytes                    = 2;                            { Video sResource parameter Id's  }
  46.     mBounds                        = 3;                            { Video sResource parameter Id's  }
  47.     mVersion                    = 4;                            { Video sResource parameter Id's  }
  48.     mHRes                        = 5;                            { Video sResource parameter Id's  }
  49.     mVRes                        = 6;                            { Video sResource parameter Id's  }
  50.     mPixelType                    = 7;                            { Video sResource parameter Id's  }
  51.     mPixelSize                    = 8;                            { Video sResource parameter Id's  }
  52.     mCmpCount                    = 9;                            { Video sResource parameter Id's  }
  53.     mCmpSize                    = 10;                            { Video sResource parameter Id's  }
  54.     mPlaneBytes                    = 11;                            { Video sResource parameter Id's  }
  55.     mVertRefRate                = 14;                            { Video sResource parameter Id's  }
  56.     mVidParams                    = 1;                            { Video parameter block id. }
  57.     mTable                        = 2;                            { Offset to the table. }
  58.     mPageCnt                    = 3;                            { Number of pages }
  59.     mDevType                    = 4;                            { Device Type }
  60.     oneBitMode                    = 128;                            { Id of OneBitMode Parameter list. }
  61.     twoBitMode                    = 129;                            { Id of TwoBitMode Parameter list. }
  62.     fourBitMode                    = 130;                            { Id of FourBitMode Parameter list. }
  63.     eightBitMode                = 131;                            { Id of EightBitMode Parameter list. }
  64.  
  65.     sixteenBitMode                = 132;                            { Id of SixteenBitMode Parameter list. }
  66.     thirtyTwoBitMode            = 133;                            { Id of ThirtyTwoBitMode Parameter list. }
  67.     firstVidMode                = 128;                            { The new, better way to do the above.  }
  68.     secondVidMode                = 129;                            {  QuickDraw only supports six video  }
  69.     thirdVidMode                = 130;                            {  at this time.       }
  70.     fourthVidMode                = 131;
  71.     fifthVidMode                = 132;
  72.     sixthVidMode                = 133;
  73.     spGammaDir                    = 64;
  74.     spVidNamesDir                = 65;
  75.  
  76.  
  77. { csTimingFormat values in VDTimingInfo }
  78. { look in the declaration rom for timing info }
  79.     kDeclROMtables                = 'decl';
  80.  
  81. { Size of a block of EDID (Extended Display Identification Data) }
  82.     kDDCBlockSize                = 128;
  83.  
  84. {  ddcBlockType constants }
  85.     kDDCBlockTypeEDID            = 0;                            {  EDID block type.  }
  86.  
  87. {  ddcFlags constants }
  88.     kDDCForceReadBit            = 0;                            {  Force a new read of the EDID.  }
  89.     kDDCForceReadMask            = $01;                            {  Mask for kddcForceReadBit.  }
  90.  
  91.  
  92. { Timing mode constants for Display Manager MultiMode support
  93.     Corresponding    .h equates are in Video.h
  94.                     .a equates are in Video.a
  95.                     .r equates are in DepVideoEqu.r
  96.     
  97.     The second enum is the old names (for compatibility).
  98.     The first enum is the new names.
  99. }
  100.     timingInvalid                = 0;                            {     Unknown timing… force user to confirm.  }
  101.     timingInvalid_SM_T24        = 8;                            {     Work around bug in SM Thunder24 card. }
  102.     timingApple_FixedRateLCD    = 42;                            {     Lump all fixed-rate LCDs into one category. }
  103.     timingApple_512x384_60hz    = 130;                            {   512x384  (60 Hz) Rubik timing.  }
  104.     timingApple_560x384_60hz    = 135;                            {   560x384  (60 Hz) Rubik-560 timing.  }
  105.     timingApple_640x480_67hz    = 140;                            {   640x480  (67 Hz) HR timing.  }
  106.     timingApple_640x400_67hz    = 145;                            {   640x400  (67 Hz) HR-400 timing.  }
  107.     timingVESA_640x480_60hz        = 150;                            {   640x480  (60 Hz) VGA timing.  }
  108.     timingVESA_640x480_72hz        = 152;                            {   640x480  (72 Hz) VGA timing.  }
  109.     timingVESA_640x480_75hz        = 154;                            {   640x480  (75 Hz) VGA timing.  }
  110.     timingVESA_640x480_85hz        = 158;                            {   640x480  (85 Hz) VGA timing.  }
  111.     timingGTF_640x480_120hz        = 159;                            {   640x480  (120 Hz) VESA Generalized Timing Formula  }
  112.     timingApple_640x870_75hz    = 160;                            {   640x870  (75 Hz) FPD timing. }
  113.     timingApple_640x818_75hz    = 165;                            {   640x818  (75 Hz) FPD-818 timing. }
  114.     timingApple_832x624_75hz    = 170;                            {   832x624  (75 Hz) GoldFish timing. }
  115.     timingVESA_800x600_56hz        = 180;                            {   800x600  (56 Hz) SVGA timing.  }
  116.     timingVESA_800x600_60hz        = 182;                            {   800x600  (60 Hz) SVGA timing.  }
  117.     timingVESA_800x600_72hz        = 184;                            {   800x600  (72 Hz) SVGA timing.  }
  118.     timingVESA_800x600_75hz        = 186;                            {   800x600  (75 Hz) SVGA timing.  }
  119.     timingVESA_800x600_85hz        = 188;                            {   800x600  (85 Hz) SVGA timing.  }
  120.     timingVESA_1024x768_60hz    = 190;                            {  1024x768  (60 Hz) VESA 1K-60Hz timing.  }
  121.     timingVESA_1024x768_70hz    = 200;                            {  1024x768  (70 Hz) VESA 1K-70Hz timing.  }
  122.     timingVESA_1024x768_75hz    = 204;                            {  1024x768  (75 Hz) VESA 1K-75Hz timing (very similar to timingApple_1024x768_75hz).  }
  123.     timingVESA_1024x768_85hz    = 208;                            {  1024x768  (85 Hz) VESA timing.  }
  124.     timingApple_1024x768_75hz    = 210;                            {  1024x768  (75 Hz) Apple 19" RGB.  }
  125.     timingApple_1152x870_75hz    = 220;                            {  1152x870  (75 Hz) Apple 21" RGB.  }
  126.     timingAppleNTSC_ST            = 230;                            {   512x384  (60 Hz, interlaced, non-convolved).  }
  127.     timingAppleNTSC_FF            = 232;                            {   640x480  (60 Hz, interlaced, non-convolved).  }
  128.     timingAppleNTSC_STconv        = 234;                            {   512x384  (60 Hz, interlaced, convolved).  }
  129.     timingAppleNTSC_FFconv        = 236;                            {   640x480  (60 Hz, interlaced, convolved).  }
  130.     timingApplePAL_ST            = 238;                            {   640x480  (50 Hz, interlaced, non-convolved).  }
  131.     timingApplePAL_FF            = 240;                            {   768x576  (50 Hz, interlaced, non-convolved).  }
  132.     timingApplePAL_STconv        = 242;                            {   640x480  (50 Hz, interlaced, convolved).  }
  133.     timingApplePAL_FFconv        = 244;                            {   768x576  (50 Hz, interlaced, convolved).  }
  134.     timingVESA_1280x960_75hz    = 250;                            {  1280x960  (75 Hz)  }
  135.     timingVESA_1280x960_60hz    = 252;                            {  1280x960  (60 Hz)  }
  136.     timingVESA_1280x960_85hz    = 254;                            {  1280x960  (85 Hz)  }
  137.     timingVESA_1280x1024_60hz    = 260;                            {  1280x1024 (60 Hz)  }
  138.     timingVESA_1280x1024_75hz    = 262;                            {  1280x1024 (75 Hz)  }
  139.     timingVESA_1280x1024_85hz    = 268;                            {  1280x1024 (85 Hz)  }
  140.     timingVESA_1600x1200_60hz    = 280;                            {  1600x1200 (60 Hz) VESA timing.  }
  141.     timingVESA_1600x1200_65hz    = 282;                            {  1600x1200 (65 Hz) VESA timing.  }
  142.     timingVESA_1600x1200_70hz    = 284;                            {  1600x1200 (70 Hz) VESA timing.  }
  143.     timingVESA_1600x1200_75hz    = 286;                            {  1600x1200 (75 Hz) VESA timing (pixel clock is 189.2 Mhz dot clock).  }
  144.     timingVESA_1600x1200_80hz    = 288;                            {  1600x1200 (80 Hz) VESA timing (pixel clock is 216>? Mhz dot clock) - proposed only.  }
  145.     timingVESA_1600x1200_85hz    = 289;                            {  1600x1200 (85 Hz) VESA timing (pixel clock is 229.5 Mhz dot clock).  }
  146.     timingSMPTE240M_60hz        = 400;                            {  60Hz V, 33.75KHz H, interlaced timing, 16:9 aspect, typical resolution of 1920x1035.  }
  147.     timingFilmRate_48hz            = 410;                            {  48Hz V, 25.20KHz H, non-interlaced timing, typical resolution of 640x480.  }
  148.     timingSony_1600x1024_76hz    = 500;                            {  1600x1024 (76 Hz) Sony timing (pixel clock is 170.447 Mhz dot clock).  }
  149.     timingSony_1920x1080_60hz    = 510;                            {  1920x1080 (60 Hz) Sony timing (pixel clock is 159.84 Mhz dot clock).  }
  150.     timingSony_1920x1080_72hz    = 520;                            {  1920x1080 (72 Hz) Sony timing (pixel clock is 216.023 Mhz dot clock).  }
  151.     timingSony_1900x1200_74hz    = 530;                            {  1900x1200 (74 Hz) Sony timing (pixel clock is 236.25 Mhz dot clock).  }
  152.     timingSony_1900x1200_76hz    = 540;                            {  1900x1200 (76 Hz) Sony timing (pixel clock is 245.48 Mhz dot clock).  }
  153.  
  154.  
  155. {  Deprecated timing names. }
  156.     timingApple12                = 130;
  157.     timingApple12x                = 135;
  158.     timingApple13                = 140;
  159.     timingApple13x                = 145;
  160.     timingAppleVGA                = 150;
  161.     timingApple15                = 160;
  162.     timingApple15x                = 165;
  163.     timingApple16                = 170;
  164.     timingAppleSVGA                = 180;
  165.     timingApple1Ka                = 190;
  166.     timingApple1Kb                = 200;
  167.     timingApple19                = 210;
  168.     timingApple21                = 220;
  169.  
  170. { csConnectFlags values in VDDisplayConnectInfo }
  171.     kAllModesValid                = 0;                            {  All modes not trimmed by primary init are good close enough to try  }
  172.     kAllModesSafe                = 1;                            {  All modes not trimmed by primary init are know to be safe  }
  173.     kReportsTagging                = 2;                            {  Can detect tagged displays (to identify smart monitors)  }
  174.     kHasDirectConnection        = 3;                            {  True implies that driver can talk directly to device (e.g. serial data link via sense lines)  }
  175.     kIsMonoDev                    = 4;                            {  Says whether there’s an RGB (0) or Monochrome (1) connection.  }
  176.     kUncertainConnection        = 5;                            {  There may not be a display (no sense lines?).  }
  177.     kTaggingInfoNonStandard        = 6;                            {  Set when csConnectTaggedType/csConnectTaggedData are non-standard (i.e., not the Apple CRT sense codes).  }
  178.     kReportsDDCConnection        = 7;                            {  Card can do ddc (set kHasDirectConnect && kHasDDCConnect if you actually found a ddc display).  }
  179.     kHasDDCConnection            = 8;                            {  Card has ddc connect now.  }
  180.     kConnectionInactive            = 9;                            {  Set when the connection is NOT currently active (generally used in a multiconnection environment).  }
  181.     kDependentConnection        = 10;                            {  Set when some ascpect of THIS connection depends on another (will generally be set in a kModeSimulscan environment).  }
  182.     kBuiltInConnection            = 11;                            {  Set when connection is KNOWN to be built-in (this is not the same as kHasDirectConnection).  }
  183.     kOverrideConnection            = 12;                            {  Set when the reported connection is not the true one, but is one that has been forced through a SetConnection call  }
  184.     kFastCheckForDDC            = 13;                            {  Set when all 3 are true: 1) sense codes indicate DDC display could be attached 2) attempted fast check 3) DDC failed  }
  185.  
  186.  
  187. { csDisplayType values in VDDisplayConnectInfo }
  188.     kUnknownConnect                = 1;                            {  Not sure how we’ll use this, but seems like a good idea.  }
  189.     kPanelConnect                = 2;                            {  For use with fixed-in-place LCD panels.  }
  190.     kPanelTFTConnect            = 2;                            {  Alias for kPanelConnect  }
  191.     kFixedModeCRTConnect        = 3;                            {   For use with fixed-mode (i.e., very limited range) displays.  }
  192.     kMultiModeCRT1Connect        = 4;                            {  320x200 maybe, 12" maybe, 13" (default), 16" certain, 19" maybe, 21" maybe  }
  193.     kMultiModeCRT2Connect        = 5;                            {  320x200 maybe, 12" maybe, 13" certain, 16" (default), 19" certain, 21" maybe  }
  194.     kMultiModeCRT3Connect        = 6;                            {  320x200 maybe, 12" maybe, 13" certain, 16" certain, 19" default, 21" certain  }
  195.     kMultiModeCRT4Connect        = 7;                            {  Expansion to large multi mode (not yet used)  }
  196.     kModelessConnect            = 8;                            {  Expansion to modeless model (not yet used)  }
  197.     kFullPageConnect            = 9;                            {  640x818 (to get 8bpp in 512K case) and 640x870 (these two only)  }
  198.     kVGAConnect                    = 10;                            {  640x480 VGA default -- question everything else  }
  199.     kNTSCConnect                = 11;                            {  NTSC ST (default), FF, STconv, FFconv  }
  200.     kPALConnect                    = 12;                            {  PAL ST (default), FF, STconv, FFconv  }
  201.     kHRConnect                    = 13;                            {  Straight-6 connect -- 640x480 and 640x400 (to get 8bpp in 256K case) (these two only)  }
  202.     kPanelFSTNConnect            = 14;                            {  For use with fixed-in-place LCD FSTN (aka “Supertwist”) panels  }
  203.     kMonoTwoPageConnect            = 15;                            {  1152x870 Apple color two-page display  }
  204.     kColorTwoPageConnect        = 16;                            {  1152x870 Apple B&W two-page display  }
  205.     kColor16Connect                = 17;                            {  832x624 Apple B&W two-page display  }
  206.     kColor19Connect                = 18;                            {  1024x768 Apple B&W two-page display  }
  207.     kGenericCRT                    = 19;                            {  Indicates nothing except that connection is CRT in nature.  }
  208.     kGenericLCD                    = 20;                            {  Indicates nothing except that connection is LCD in nature.  }
  209.     kDDCConnect                    = 21;                            {  DDC connection, always set kHasDDCConnection  }
  210.  
  211. { csTimingFlags values in VDTimingInfoRec }
  212.     kModeValid                    = 0;                            {  Says that this mode should NOT be trimmed.  }
  213.     kModeSafe                    = 1;                            {  This mode does not need confirmation  }
  214.     kModeDefault                = 2;                            {  This is the default mode for this type of connection  }
  215.     kModeShowNow                = 3;                            {  This mode should always be shown (even though it may require a confirm)  }
  216.     kModeNotResize                = 4;                            {  This mode should not be used to resize the display (eg. mode selects a different connector on card)  }
  217.     kModeRequiresPan            = 5;                            {  This mode has more pixels than are actually displayed  }
  218.     kModeInterlaced                = 6;                            {  This mode is interlaced (single pixel lines look bad).  }
  219.     kModeShowNever                = 7;                            {  This mode should not be shown in the user interface.  }
  220.     kModeSimulscan                = 8;                            {  Indicates that more than one display connection can be driven from a single framebuffer controller.  }
  221.     kModeNotPreset                = 9;                            {  Indicates that the timing is not a factory preset for the current display (geometry may need correction)  }
  222.     kModeBuiltIn                = 10;                            {  Indicates that the display mode is for the built-in connect only (on multiconnect devices like the PB 3400) Only the driver is quieried  }
  223.  
  224. { csDepthFlags in VDVideoParametersInfoRec }
  225.     kDepthDependent                = 0;                            {  Says that this depth mode may cause dependent changes in other framebuffers (and .  }
  226.  
  227. { csResolutionFlags bit flags for VDResolutionInfoRec }
  228.     kResolutionHasMultipleDepthSizes = 0;                        {  Says that this mode has different csHorizontalPixels, csVerticalLines at different depths (usually slightly larger at lower depths)  }
  229.  
  230.  
  231.                                                                 {     Power Mode constants for VDPowerStateRec.powerState.  Note the numeric order does not match the power state order  }
  232.     kAVPowerOff                    = 0;                            {  Power fully off }
  233.     kAVPowerStandby                = 1;
  234.     kAVPowerSuspend                = 2;
  235.     kAVPowerOn                    = 3;
  236.  
  237.                                                                 {     Power Mode masks and bits for VDPowerStateRec.powerFlags.     }
  238.     kPowerStateNeedsRefresh        = 0;                            {  When leaving this power mode, a display will need refreshing     }
  239.     kPowerStateSleepAwareBit    = 1;                            {  if gestaltPCCardDockingSelectorFix, Docking mgr checks this bit before checking kPowerStateSleepAllowedBit  }
  240.     kPowerStateSleepForbiddenBit = 2;                            {  if kPowerStateSleepAwareBit, Docking mgr checks this bit before sleeping  }
  241.     kPowerStateNeedsRefreshMask    = $00000001;
  242.     kPowerStateSleepAwareMask    = $00000002;
  243.     kPowerStateSleepForbiddenMask = $00000004;
  244.  
  245.  
  246.                                                                 {  Control Codes  }
  247.     cscReset                    = 0;
  248.     cscKillIO                    = 1;
  249.     cscSetMode                    = 2;
  250.     cscSetEntries                = 3;
  251.     cscSetGamma                    = 4;
  252.     cscGrayPage                    = 5;
  253.     cscGrayScreen                = 5;
  254.     cscSetGray                    = 6;
  255.     cscSetInterrupt                = 7;
  256.     cscDirectSetEntries            = 8;
  257.     cscSetDefaultMode            = 9;
  258.     cscSwitchMode                = 10;
  259.     cscSetSync                    = 11;
  260.     cscSavePreferredConfiguration = 16;
  261.     cscSetHardwareCursor        = 22;
  262.     cscDrawHardwareCursor        = 23;
  263.     cscSetConvolution            = 24;
  264.     cscSetPowerState            = 25;
  265.     cscPrivateControlCall        = 26;                            {  Takes a VDPrivateSelectorDataRec }
  266.     cscSetMultiConnect            = 28;                            {  From a GDI point of view, this call should be implemented completely in the HAL and not at all in the core. }
  267.     cscSetClutBehavior            = 29;                            {  Takes a VDClutBehavior  }
  268.     cscUnusedCall                = 127;                            {  This call used to expend the scrn resource.  Its imbedded data contains more control info  }
  269.  
  270.                                                                 {  Status Codes  }
  271.     cscGetMode                    = 2;
  272.     cscGetEntries                = 3;
  273.     cscGetPageCnt                = 4;
  274.     cscGetPages                    = 4;                            {  This is what C&D 2 calls it.  }
  275.     cscGetPageBase                = 5;
  276.     cscGetBaseAddr                = 5;                            {  This is what C&D 2 calls it.  }
  277.     cscGetGray                    = 6;
  278.     cscGetInterrupt                = 7;
  279.     cscGetGamma                    = 8;
  280.     cscGetDefaultMode            = 9;
  281.     cscGetCurMode                = 10;
  282.     cscGetSync                    = 11;
  283.     cscGetConnection            = 12;                            {  Return information about the connection to the display  }
  284.     cscGetModeTiming            = 13;                            {  Return timing info for a mode  }
  285.     cscGetModeBaseAddress        = 14;                            {  Return base address information about a particular mode  }
  286.     cscGetScanProc                = 15;                            {  QuickTime scan chasing routine  }
  287.     cscGetPreferredConfiguration = 16;
  288.     cscGetNextResolution        = 17;
  289.     cscGetVideoParameters        = 18;
  290.     cscGetGammaInfoList            = 20;
  291.     cscRetrieveGammaTable        = 21;
  292.     cscSupportsHardwareCursor    = 22;
  293.     cscGetHardwareCursorDrawState = 23;
  294.     cscGetConvolution            = 24;
  295.     cscGetPowerState            = 25;
  296.     cscPrivateStatusCall        = 26;                            {  Takes a VDPrivateSelectorDataRec }
  297.     cscGetDDCBlock                = 27;                            {  Takes a VDDDCBlockRec   }
  298.     cscGetMultiConnect            = 28;                            {  From a GDI point of view, this call should be implemented completely in the HAL and not at all in the core. }
  299.     cscGetClutBehavior            = 29;                            {  Takes a VDClutBehavior  }
  300.  
  301. {  Bit definitions for the Get/Set Sync call }
  302.     kDisableHorizontalSyncBit    = 0;
  303.     kDisableVerticalSyncBit        = 1;
  304.     kDisableCompositeSyncBit    = 2;
  305.     kEnableSyncOnBlue            = 3;
  306.     kEnableSyncOnGreen            = 4;
  307.     kEnableSyncOnRed            = 5;
  308.     kNoSeparateSyncControlBit    = 6;
  309.     kTriStateSyncBit            = 7;
  310.     kHorizontalSyncMask            = $01;
  311.     kVerticalSyncMask            = $02;
  312.     kCompositeSyncMask            = $04;
  313.     kDPMSSyncMask                = $07;
  314.     kTriStateSyncMask            = $80;
  315.     kSyncOnBlueMask                = $08;
  316.     kSyncOnGreenMask            = $10;
  317.     kSyncOnRedMask                = $20;
  318.     kSyncOnMask                    = $38;
  319.  
  320.                                                                 {     Power Mode constants for translating DPMS modes to Get/SetSync calls.     }
  321.     kDPMSSyncOn                    = 0;
  322.     kDPMSSyncStandby            = 1;
  323.     kDPMSSyncSuspend            = 2;
  324.     kDPMSSyncOff                = 7;
  325.  
  326. {  Bit definitions for the Get/Set Convolution call }
  327.     kConvolved                    = 0;
  328.     kLiveVideoPassThru            = 1;
  329.     kConvolvedMask                = $01;
  330.     kLiveVideoPassThruMask        = $02;
  331.  
  332.  
  333.  
  334. TYPE
  335.     VPBlockPtr = ^VPBlock;
  336.     VPBlock = RECORD
  337.         vpBaseOffset:            LONGINT;                                { Offset to page zero of video RAM (From minorBaseOS). }
  338.         vpRowBytes:                INTEGER;                                { Width of each row of video memory. }
  339.         vpBounds:                Rect;                                    { BoundsRect for the video display (gives dimensions). }
  340.         vpVersion:                INTEGER;                                { PixelMap version number. }
  341.         vpPackType:                INTEGER;
  342.         vpPackSize:                LONGINT;
  343.         vpHRes:                    LONGINT;                                { Horizontal resolution of the device (pixels per inch). }
  344.         vpVRes:                    LONGINT;                                { Vertical resolution of the device (pixels per inch). }
  345.         vpPixelType:            INTEGER;                                { Defines the pixel type. }
  346.         vpPixelSize:            INTEGER;                                { Number of bits in pixel. }
  347.         vpCmpCount:                INTEGER;                                { Number of components in pixel. }
  348.         vpCmpSize:                INTEGER;                                { Number of bits per component }
  349.         vpPlaneBytes:            LONGINT;                                { Offset from one plane to the next. }
  350.     END;
  351.  
  352.     VDEntryRecordPtr = ^VDEntryRecord;
  353.     VDEntryRecord = RECORD
  354.         csTable:                Ptr;                                    { (long) pointer to color table entry=value, r,g,b:INTEGER }
  355.     END;
  356.  
  357.     VDEntRecPtr                            = ^VDEntryRecord;
  358. { Parm block for SetGray control call }
  359.     VDGrayRecordPtr = ^VDGrayRecord;
  360.     VDGrayRecord = RECORD
  361.         csMode:                    BOOLEAN;                                { Same as GDDevType value (0=color, 1=mono) }
  362.         filler:                    SInt8;
  363.     END;
  364.  
  365.     VDGrayPtr                            = ^VDGrayRecord;
  366. { Parm block for SetInterrupt call }
  367.     VDFlagRecordPtr = ^VDFlagRecord;
  368.     VDFlagRecord = RECORD
  369.         csMode:                    SInt8;
  370.         filler:                    SInt8;
  371.     END;
  372.  
  373.     VDFlagRecPtr                        = ^VDFlagRecord;
  374. { Parm block for SetEntries control call }
  375.     VDSetEntryRecordPtr = ^VDSetEntryRecord;
  376.     VDSetEntryRecord = RECORD
  377.         csTable:                ColorSpecPtr;                            { Pointer to an array of color specs }
  378.         csStart:                INTEGER;                                { Which spec in array to start with, or -1 }
  379.         csCount:                INTEGER;                                { Number of color spec entries to set }
  380.     END;
  381.  
  382.     VDSetEntryPtr                        = ^VDSetEntryRecord;
  383. { Parm block for SetGamma control call }
  384.     VDGammaRecordPtr = ^VDGammaRecord;
  385.     VDGammaRecord = RECORD
  386.         csGTable:                Ptr;                                    { pointer to gamma table }
  387.     END;
  388.  
  389.     VDGamRecPtr                            = ^VDGammaRecord;
  390.     VDBaseAddressInfoRecPtr = ^VDBaseAddressInfoRec;
  391.     VDBaseAddressInfoRec = RECORD
  392.         csDevData:                LONGINT;                                {  LONGINT - (long) timing mode  }
  393.         csDevBase:                LONGINT;                                {  LONGINT - (long) base address of the mode  }
  394.         csModeReserved:            INTEGER;                                {  INTEGER - (short) will some day be the depth  }
  395.         csModeBase:                LONGINT;                                {  LONGINT - (long) reserved  }
  396.     END;
  397.  
  398.     VDBaseAddressInfoPtr                = ^VDBaseAddressInfoRec;
  399.     VDSwitchInfoRecPtr = ^VDSwitchInfoRec;
  400.     VDSwitchInfoRec = RECORD
  401.         csMode:                    UInt16;                                    { (word) mode depth }
  402.         csData:                    UInt32;                                    { (long) functional sResource of mode }
  403.         csPage:                    UInt16;                                    { (word) page to switch in }
  404.         csBaseAddr:                Ptr;                                    { (long) base address of page (return value) }
  405.         csReserved:                UInt32;                                    { (long) Reserved (set to 0)  }
  406.     END;
  407.  
  408.     VDSwitchInfoPtr                        = ^VDSwitchInfoRec;
  409.     VDTimingInfoRecPtr = ^VDTimingInfoRec;
  410.     VDTimingInfoRec = RECORD
  411.         csTimingMode:            UInt32;                                    {  LONGINT - (long) timing mode (a la InitGDevice)  }
  412.         csTimingReserved:        UInt32;                                    {  LONGINT - (long) reserved  }
  413.         csTimingFormat:            UInt32;                                    {  LONGINT - (long) what format is the timing info  }
  414.         csTimingData:            UInt32;                                    {  LONGINT - (long) data supplied by driver  }
  415.         csTimingFlags:            UInt32;                                    {  LONGINT - (long) mode within device  }
  416.     END;
  417.  
  418.     VDTimingInfoPtr                        = ^VDTimingInfoRec;
  419.     VDDisplayConnectInfoRecPtr = ^VDDisplayConnectInfoRec;
  420.     VDDisplayConnectInfoRec = RECORD
  421.         csDisplayType:            UInt16;                                    {  INTEGER - (word) Type of display connected  }
  422.         csConnectTaggedType:    SInt8;                                    {  BYTE - type of tagging  }
  423.         csConnectTaggedData:    SInt8;                                    {  BYTE - tagging data  }
  424.         csConnectFlags:            UInt32;                                    {  LONGINT - (long) tell us about the connection  }
  425.         csDisplayComponent:        UInt32;                                    {  LONGINT - (long) if the card has a direct connection to the display, it returns the display component here (FUTURE)  }
  426.         csConnectReserved:        UInt32;                                    {  LONGINT - (long) reserved  }
  427.     END;
  428.  
  429.     VDDisplayConnectInfoPtr                = ^VDDisplayConnectInfoRec;
  430.     VDMultiConnectInfoRecPtr = ^VDMultiConnectInfoRec;
  431.     VDMultiConnectInfoRec = RECORD
  432.         csDisplayCountOrNumber:    UInt32;                                    {  For GetMultiConnect, returns count n of 1..n connections; otherwise, indicates the ith connection. }
  433.         csConnectInfo:            VDDisplayConnectInfoRec;                {  Standard VDDisplayConnectionInfo for connection i. }
  434.     END;
  435.  
  436.     VDMultiConnectInfoPtr                = ^VDMultiConnectInfoRec;
  437. { RawSenseCode
  438.     This abstract data type is not exactly abstract.  Rather, it is merely enumerated constants
  439.     for the possible raw sense code values when 'standard' sense code hardware is implemented.
  440.  
  441.     For 'standard' sense code hardware, the raw sense is obtained as follows:
  442.         • Instruct the frame buffer controller NOT to actively drive any of the monitor sense lines
  443.         • Read the state of the monitor sense lines 2, 1, and 0.  (2 is the MSB, 0 the LSB)
  444.  
  445.     IMPORTANT Note: 
  446.     When the 'kTaggingInfoNonStandard' bit of 'csConnectFlags' is FALSE, then these constants 
  447.     are valid 'csConnectTaggedType' values in 'VDDisplayConnectInfo' 
  448.  
  449. }
  450.     RawSenseCode                        = UInt8;
  451.  
  452. CONST
  453.     kRSCZero                    = 0;
  454.     kRSCOne                        = 1;
  455.     kRSCTwo                        = 2;
  456.     kRSCThree                    = 3;
  457.     kRSCFour                    = 4;
  458.     kRSCFive                    = 5;
  459.     kRSCSix                        = 6;
  460.     kRSCSeven                    = 7;
  461.  
  462.  
  463. { ExtendedSenseCode
  464.     This abstract data type is not exactly abstract.  Rather, it is merely enumerated constants
  465.     for the values which are possible when the extended sense algorithm is applied to hardware
  466.     which implements 'standard' sense code hardware.
  467.  
  468.      For 'standard' sense code hardware, the extended sense code algorithm is as follows:
  469.     (Note:  as described here, sense line 'A' corresponds to '2', 'B' to '1', and 'C' to '0')
  470.         • Drive sense line 'A' low and read the values of 'B' and 'C'.  
  471.         • Drive sense line 'B' low and read the values of 'A' and 'C'.
  472.         • Drive sense line 'C' low and read the values of 'A' and 'B'.
  473.  
  474.     In this way, a six-bit number of the form BC/AC/AB is generated. 
  475.  
  476.     IMPORTANT Note: 
  477.     When the 'kTaggingInfoNonStandard' bit of 'csConnectFlags' is FALSE, then these constants 
  478.     are valid 'csConnectTaggedData' values in 'VDDisplayConnectInfo' 
  479.  
  480. }
  481.  
  482. TYPE
  483.     ExtendedSenseCode                    = UInt8;
  484.  
  485. CONST
  486.     kESCZero21Inch                = $00;                            {  21" RGB                                  }
  487.     kESCOnePortraitMono            = $14;                            {  Portrait Monochrome                      }
  488.     kESCTwo12Inch                = $21;                            {  12" RGB                                 }
  489.     kESCThree21InchRadius        = $31;                            {  21" RGB (Radius)                         }
  490.     kESCThree21InchMonoRadius    = $34;                            {  21" Monochrome (Radius)                  }
  491.     kESCThree21InchMono            = $35;                            {  21" Monochrome                         }
  492.     kESCFourNTSC                = $0A;                            {  NTSC                                  }
  493.     kESCFivePortrait            = $1E;                            {  Portrait RGB                          }
  494.     kESCSixMSB1                    = $03;                            {  MultiScan Band-1 (12" thru 1Six")     }
  495.     kESCSixMSB2                    = $0B;                            {  MultiScan Band-2 (13" thru 19")         }
  496.     kESCSixMSB3                    = $23;                            {  MultiScan Band-3 (13" thru 21")         }
  497.     kESCSixStandard                = $2B;                            {  13"/14" RGB or 12" Monochrome         }
  498.     kESCSevenPAL                = $00;                            {  PAL                                     }
  499.     kESCSevenNTSC                = $14;                            {  NTSC                                  }
  500.     kESCSevenVGA                = $17;                            {  VGA                                      }
  501.     kESCSeven16Inch                = $2D;                            {  16" RGB (GoldFish)                       }
  502.     kESCSevenPALAlternate        = $30;                            {  PAL (Alternate)                          }
  503.     kESCSeven19Inch                = $3A;                            {  Third-Party 19”                         }
  504.     kESCSevenDDC                = $3E;                            {  DDC display                             }
  505.     kESCSevenNoDisplay            = $3F;                            {  No display connected                  }
  506.  
  507. { DepthMode
  508.     This abstract data type is used to to reference RELATIVE pixel depths.
  509.     Its definition is largely derived from its past usage, analogous to 'xxxVidMode'
  510.  
  511.     Bits per pixel DOES NOT directly map to 'DepthMode'  For example, on some
  512.     graphics hardware, 'kDepthMode1' may represent 1 BPP, whereas on other
  513.     hardware, 'kDepthMode1' may represent 8BPP.
  514.  
  515.     DepthMode IS considered to be ordinal, i.e., operations such as <, >, ==, etc.
  516.     behave as expected.  The values of the constants which comprise the set are such
  517.     that 'kDepthMode4 < kDepthMode6' behaves as expected.
  518. }
  519.  
  520. TYPE
  521.     DepthMode                            = UInt16;
  522.  
  523. CONST
  524.     kDepthMode1                    = 128;
  525.     kDepthMode2                    = 129;
  526.     kDepthMode3                    = 130;
  527.     kDepthMode4                    = 131;
  528.     kDepthMode5                    = 132;
  529.     kDepthMode6                    = 133;
  530.  
  531.     kFirstDepthMode                = 128;                            {  These constants are obsolete, and just included     }
  532.     kSecondDepthMode            = 129;                            {  for clients that have converted to the above         }
  533.     kThirdDepthMode                = 130;                            {  kDepthModeXXX constants.                             }
  534.     kFourthDepthMode            = 131;
  535.     kFifthDepthMode                = 132;
  536.     kSixthDepthMode                = 133;
  537.  
  538.  
  539.  
  540. TYPE
  541.     VDPageInfoPtr = ^VDPageInfo;
  542.     VDPageInfo = RECORD
  543.         csMode:                    INTEGER;                                { (word) mode within device }
  544.         csData:                    LONGINT;                                { (long) data supplied by driver }
  545.         csPage:                    INTEGER;                                { (word) page to switch in }
  546.         csBaseAddr:                Ptr;                                    { (long) base address of page }
  547.     END;
  548.  
  549.     VDPgInfoPtr                            = ^VDPageInfo;
  550.     VDSizeInfoPtr = ^VDSizeInfo;
  551.     VDSizeInfo = RECORD
  552.         csHSize:                INTEGER;                                { (word) desired/returned h size }
  553.         csHPos:                    INTEGER;                                { (word) desired/returned h position }
  554.         csVSize:                INTEGER;                                { (word) desired/returned v size }
  555.         csVPos:                    INTEGER;                                { (word) desired/returned v position }
  556.     END;
  557.  
  558.     VDSzInfoPtr                            = ^VDSizeInfo;
  559.     VDSettingsPtr = ^VDSettings;
  560.     VDSettings = RECORD
  561.         csParamCnt:                INTEGER;                                { (word) number of params }
  562.         csBrightMax:            INTEGER;                                { (word) max brightness }
  563.         csBrightDef:            INTEGER;                                { (word) default brightness }
  564.         csBrightVal:            INTEGER;                                { (word) current brightness }
  565.         csCntrstMax:            INTEGER;                                { (word) max contrast }
  566.         csCntrstDef:            INTEGER;                                { (word) default contrast }
  567.         csCntrstVal:            INTEGER;                                { (word) current contrast }
  568.         csTintMax:                INTEGER;                                { (word) max tint }
  569.         csTintDef:                INTEGER;                                { (word) default tint }
  570.         csTintVal:                INTEGER;                                { (word) current tint }
  571.         csHueMax:                INTEGER;                                { (word) max hue }
  572.         csHueDef:                INTEGER;                                { (word) default hue }
  573.         csHueVal:                INTEGER;                                { (word) current hue }
  574.         csHorizDef:                INTEGER;                                { (word) default horizontal }
  575.         csHorizVal:                INTEGER;                                { (word) current horizontal }
  576.         csHorizMax:                INTEGER;                                { (word) max horizontal }
  577.         csVertDef:                INTEGER;                                { (word) default vertical }
  578.         csVertVal:                INTEGER;                                { (word) current vertical }
  579.         csVertMax:                INTEGER;                                { (word) max vertical }
  580.     END;
  581.  
  582.     VDDefModePtr = ^VDDefMode;
  583.     VDDefMode = RECORD
  584.         csID:                    SInt8;
  585.         filler:                    SInt8;
  586.     END;
  587.  
  588.     VDSyncInfoRecPtr = ^VDSyncInfoRec;
  589.     VDSyncInfoRec = RECORD
  590.         csMode:                    SInt8;
  591.         csFlags:                SInt8;
  592.     END;
  593.  
  594.     VDSyncInfoPtr                        = ^VDSyncInfoRec;
  595.     DisplayModeID                        = UInt32;
  596.     VideoDeviceType                        = UInt32;
  597.     GammaTableID                        = UInt32;
  598. { Constants for the GetNextResolution call }
  599.  
  600. CONST
  601.     kDisplayModeIDCurrent        = $00;                            {  Reference the Current DisplayModeID  }
  602.     kDisplayModeIDInvalid        = $FFFFFFFF;                    {  A bogus DisplayModeID in all cases  }
  603.     kDisplayModeIDFindFirstResolution = $FFFFFFFE;                {  Used in cscGetNextResolution to reset iterator  }
  604.     kDisplayModeIDNoMoreResolutions = $FFFFFFFD;                {  Used in cscGetNextResolution to indicate End Of List  }
  605.  
  606. { Constants for the GetGammaInfoList call }
  607.     kGammaTableIDFindFirst        = $FFFFFFFE;                    {  Get the first gamma table ID  }
  608.     kGammaTableIDNoMoreTables    = $FFFFFFFD;                    {  Used to indicate end of list  }
  609.     kGammaTableIDSpecific        = $00;                            {  Return the info for the given table id  }
  610.  
  611. {  Constants for GetMultiConnect call }
  612.     kGetConnectionCount            = $FFFFFFFF;                    {  Used to get the number of possible connections in a “multi-headed” framebuffer environment. }
  613.     kActivateConnection            = $00;                            {  Used for activating a connection (csConnectFlags value). }
  614.     kDeactivateConnection        = $0200;                        {  Used for deactivating a connection (csConnectFlags value.) }
  615.  
  616.  
  617. TYPE
  618.     VDResolutionInfoRecPtr = ^VDResolutionInfoRec;
  619.     VDResolutionInfoRec = RECORD
  620.         csPreviousDisplayModeID: DisplayModeID;                            {  ID of the previous resolution in a chain  }
  621.         csDisplayModeID:        DisplayModeID;                            {  ID of the next resolution  }
  622.         csHorizontalPixels:        UInt32;                                    {  # of pixels in a horizontal line at the max depth  }
  623.         csVerticalLines:        UInt32;                                    {  # of lines in a screen at the max depth  }
  624.         csRefreshRate:            Fixed;                                    {  Vertical Refresh Rate in Hz  }
  625.         csMaxDepthMode:            DepthMode;                                {  0x80-based number representing max bit depth  }
  626.         csResolutionFlags:        UInt32;                                    {  Reserved - flag bits  }
  627.         csReserved:                UInt32;                                    {  Reserved  }
  628.     END;
  629.  
  630.     VDResolutionInfoPtr                    = ^VDResolutionInfoRec;
  631.     VDVideoParametersInfoRecPtr = ^VDVideoParametersInfoRec;
  632.     VDVideoParametersInfoRec = RECORD
  633.         csDisplayModeID:        DisplayModeID;                            {  the ID of the resolution we want info on  }
  634.         csDepthMode:            DepthMode;                                {  The bit depth we want the info on (0x80 based)  }
  635.         csVPBlockPtr:            VPBlockPtr;                                {  Pointer to a video parameter block  }
  636.         csPageCount:            UInt32;                                    {  Number of pages supported by the resolution  }
  637.         csDeviceType:            VideoDeviceType;                        {  Device Type:  Direct, Fixed or CLUT;  }
  638.         csDepthFlags:            UInt32;                                    {  Flags  }
  639.     END;
  640.  
  641.     VDVideoParametersInfoPtr            = ^VDVideoParametersInfoRec;
  642.     VDGammaInfoRecPtr = ^VDGammaInfoRec;
  643.     VDGammaInfoRec = RECORD
  644.         csLastGammaID:            GammaTableID;                            {  the ID of the previous gamma table  }
  645.         csNextGammaID:            GammaTableID;                            {  the ID of the next gamma table  }
  646.         csGammaPtr:                Ptr;                                    {  Ptr to a gamma table data  }
  647.         csReserved:                UInt32;                                    {  Reserved  }
  648.     END;
  649.  
  650.     VDGammaInfoPtr                        = ^VDGammaInfoRec;
  651.     VDGetGammaListRecPtr = ^VDGetGammaListRec;
  652.     VDGetGammaListRec = RECORD
  653.         csPreviousGammaTableID:    GammaTableID;                            {  ID of the previous gamma table  }
  654.         csGammaTableID:            GammaTableID;                            {  ID of the gamma table following csPreviousDisplayModeID  }
  655.         csGammaTableSize:        UInt32;                                    {  Size of the gamma table in bytes  }
  656.         csGammaTableName:        CStringPtr;                                {  Gamma table name (c-string)  }
  657.     END;
  658.  
  659.     VDGetGammaListPtr                    = ^VDGetGammaListRec;
  660.     VDRetrieveGammaRecPtr = ^VDRetrieveGammaRec;
  661.     VDRetrieveGammaRec = RECORD
  662.         csGammaTableID:            GammaTableID;                            {  ID of gamma table to retrieve  }
  663.         csGammaTablePtr:        GammaTblPtr;                            {  Location to copy desired gamma to  }
  664.     END;
  665.  
  666.     VDRetrieveGammaPtr                    = ^VDRetrieveGammaRec;
  667.     VDSetHardwareCursorRecPtr = ^VDSetHardwareCursorRec;
  668.     VDSetHardwareCursorRec = RECORD
  669.         csCursorRef:            Ptr;                                    {  reference to cursor data  }
  670.         csReserved1:            UInt32;                                    {  reserved for future use  }
  671.         csReserved2:            UInt32;                                    {  should be ignored  }
  672.     END;
  673.  
  674.     VDSetHardwareCursorPtr                = ^VDSetHardwareCursorRec;
  675.     VDDrawHardwareCursorRecPtr = ^VDDrawHardwareCursorRec;
  676.     VDDrawHardwareCursorRec = RECORD
  677.         csCursorX:                SInt32;                                    {  x coordinate  }
  678.         csCursorY:                SInt32;                                    {  y coordinate  }
  679.         csCursorVisible:        UInt32;                                    {  true if cursor is must be visible  }
  680.         csReserved1:            UInt32;                                    {  reserved for future use  }
  681.         csReserved2:            UInt32;                                    {  should be ignored  }
  682.     END;
  683.  
  684.     VDDrawHardwareCursorPtr                = ^VDDrawHardwareCursorRec;
  685.     VDSupportsHardwareCursorRecPtr = ^VDSupportsHardwareCursorRec;
  686.     VDSupportsHardwareCursorRec = RECORD
  687.         csSupportsHardwareCursor: UInt32;
  688.                                                                         {  true if hardware cursor is supported  }
  689.         csReserved1:            UInt32;                                    {  reserved for future use  }
  690.         csReserved2:            UInt32;                                    {  must be zero  }
  691.     END;
  692.  
  693.     VDSupportsHardwareCursorPtr            = ^VDSupportsHardwareCursorRec;
  694.     VDHardwareCursorDrawStateRecPtr = ^VDHardwareCursorDrawStateRec;
  695.     VDHardwareCursorDrawStateRec = RECORD
  696.         csCursorX:                SInt32;                                    {  x coordinate  }
  697.         csCursorY:                SInt32;                                    {  y coordinate  }
  698.         csCursorVisible:        UInt32;                                    {  true if cursor is visible  }
  699.         csCursorSet:            UInt32;                                    {  true if cursor successfully set by last set control call  }
  700.         csReserved1:            UInt32;                                    {  reserved for future use  }
  701.         csReserved2:            UInt32;                                    {  must be zero  }
  702.     END;
  703.  
  704.     VDHardwareCursorDrawStatePtr        = ^VDHardwareCursorDrawStateRec;
  705.     VDConvolutionInfoRecPtr = ^VDConvolutionInfoRec;
  706.     VDConvolutionInfoRec = RECORD
  707.         csDisplayModeID:        DisplayModeID;                            {  the ID of the resolution we want info on  }
  708.         csDepthMode:            DepthMode;                                {  The bit depth we want the info on (0x80 based)  }
  709.         csPage:                    UInt32;
  710.         csFlags:                UInt32;
  711.         csReserved:                UInt32;
  712.     END;
  713.  
  714.     VDConvolutionInfoPtr                = ^VDConvolutionInfoRec;
  715.     VDPowerStateRecPtr = ^VDPowerStateRec;
  716.     VDPowerStateRec = RECORD
  717.         powerState:                UInt32;
  718.         powerFlags:                UInt32;
  719.         powerReserved1:            UInt32;
  720.         powerReserved2:            UInt32;
  721.     END;
  722.  
  723.     VDPowerStatePtr                        = ^VDPowerStateRec;
  724. {
  725.     Private Data to video drivers.
  726.     
  727.     In versions of MacOS with multiple address spaces (System 8), the OS 
  728.     must know the extent of parameters in order to move them between the caller
  729.     and driver.  The old private-selector model for video drivers does not have
  730.     this information so:
  731.     
  732.     For post-7.x Systems private calls should be implemented using the cscPrivateCall
  733. }
  734.     VDPrivateSelectorDataRecPtr = ^VDPrivateSelectorDataRec;
  735.     VDPrivateSelectorDataRec = RECORD
  736.         privateParameters:        LogicalAddress;                            {  Caller's parameters }
  737.         privateParametersSize:    ByteCount;                                {  Size of data sent from caller to driver }
  738.         privateResults:            LogicalAddress;                            {  Caller's return area. Can be nil, or same as privateParameters. }
  739.         privateResultsSize:        ByteCount;                                {  Size of data driver returns to caller. Can be nil, or same as privateParametersSize. }
  740.     END;
  741.  
  742.     VDPrivateSelectorRecPtr = ^VDPrivateSelectorRec;
  743.     VDPrivateSelectorRec = RECORD
  744.         reserved:                UInt32;                                    {  Reserved (set to 0).  }
  745.         data:                    ARRAY [0..0] OF VDPrivateSelectorDataRec;
  746.     END;
  747.  
  748.     VDDDCBlockRecPtr = ^VDDDCBlockRec;
  749.     VDDDCBlockRec = RECORD
  750.         ddcBlockNumber:            UInt32;                                    {  Input -- DDC EDID (Extended Display Identification Data) number (1-based)  }
  751.         ddcBlockType:            ResType;                                {  Input -- DDC block type (EDID/VDIF)  }
  752.         ddcFlags:                UInt32;                                    {  Input -- DDC Flags }
  753.         ddcReserved:            UInt32;                                    {  Reserved  }
  754.         ddcBlockData:            PACKED ARRAY [0..127] OF Byte;            {  Output -- DDC EDID/VDIF data (kDDCBlockSize)  }
  755.     END;
  756.  
  757.     VDDDCBlockPtr                        = ^VDDDCBlockRec;
  758.     VDClutBehavior                        = UInt32;
  759.     VDClutBehaviorPtr                    = ^VDClutBehavior;
  760.  
  761. CONST
  762.     kSetClutAtSetEntries        = 0;                            {  SetEntries behavior is to update clut during SetEntries call }
  763.     kSetClutAtVBL                = 1;                            {  SetEntries behavior is to upate clut at next vbl }
  764.  
  765.  
  766. {$ALIGN RESET}
  767. {$POP}
  768.  
  769. {$SETC UsingIncludes := VideoIncludes}
  770.  
  771. {$ENDC} {__VIDEO__}
  772.  
  773. {$IFC NOT UsingIncludes}
  774.  END.
  775. {$ENDC}
  776.